Erick Peirson, PhD | erick.peirson@asu.edu | @captbarberousse
Last updated 20 January, 2016
In [1]:
import random # Ignore me for now!
In most real-life programming situations, you'll need to do more than a linear set of procedures. Your programs will need to be able to make decisions based on a range of possible conditions. In this notebook we'll talk about how to perform logical operations.
if and elseThe simplest form of decision-making in Python is dichotomous: if some condition is true, then do something; otherwise, do something else. If the weather is nice, then I'll wear sandals; otherwise, I'll wear shoes. If Moe and Curly win the election, I'll move to Norway; otherwise, I'll stay in New York. Notice the pattern: if...then...otherwise. In Python, we can write those kind of instructions almost as I've written the sentences above, using the statements if and else.
In [9]:
x = random.random() # This generates a random float between 0. and 1.
if x < 1./292000000: # That there's some pretty low odss.
print 'I won the powerball!'
else:
print ':-('
if says, "if the following statement is True*, then do the following...". Don't foget the colon (:) afterwards, too. The part after the if statement, print 'I won...., is indented, so that Python knows which part should be conditionally executed.
else says, "otherwise, do this...". Don't forget the colon! else is at the same level of indentation as the if statement, so that Python knows they go together. The part afterward, print ':-(', is indented, so that Python knows it's the part of the code that will get run in the "otherwise" case.
* In Python, the statement need only by "truthy" to be considered True. That is, it could be True, not 0 (or 0.0), or not an empty string.
There are all kinds of comparative operators. For a complete list, see this page.
Here's an example of how to check whether or not a particular item is contained within a list. Say, for example, that I have a list of invitees for a super-secret-underground LAN party, and I want to know if my friend is on the list.
In [15]:
invitees = ['Jack', 'Jane', 'Jim', 'Jill', 'Joseph', 'Jay', 'Josephus']
myfriend = 'Greg'
if myfriend in invitees:
print 'w00t!'
else:
print 'l4me'
If I were to win the Powerball AND my friend could come to the LAN party, it would be a pretty great day. I can check for both of those things in one statement, using the and operator.
In [16]:
x = random.random() # Come on, lucky numbers!
if myfriend in invitees and x < 1./292000000:
print 'Best day ever!'
else:
print 'meh.'
Right, pretty unlucky. But I could get over my disappointment if I saw a puppy. So I'll throw in an or operator.
In [17]:
x = random.random() # I gamble for the thrill.
is_there_a_puppy = True
if (myfriend in invitees and x < 1./292000000) or is_there_a_puppy:
print "This was much more likely, and I've adjusted my expectations."
else:
print ':-|'
Notice that I threw in some parentheses to group my evaluations. In the example above, the statement
if (myfriend in invitees and x < 1./292000000) or is_there_a_puppy:
evaluates as
if (False and False) or True:
which gets further simplified to
if False or True:
which is just
if True:
In [20]:
weather = 'blizzard'
footwear = None # I know that I'm wearing something, but I'm not sure what yet.
if weather == 'sunny': # ``==`` means "equal to".
footwear = 'sandals' # ``=`` means "assign the expression on the right to the variable on the left."
elif weather == 'blizzard':
footwear = 'snow boots'
else:
footwear = 'shoes'
print footwear
You can use as many elifs as you like!
In [21]:
weather = 'cows'
footwear = None
if weather == 'sunny':
footwear = 'sandals'
elif weather == 'blizzard':
footwear = 'snow boots'
elif weather == 'rain':
footwear = 'galoshes'
elif weather == 'cows':
footwear = 'run away!'
else:
footwear = 'shoes'
print footwear
Sure, my chances of winning the powerball are pretty low for any given draw. The real trick is to play all the time! SOMEONE has to win, right?
This kind of repetitive task calls for a loop. A loop is a control structure in which we do some series of operations repeatedly until some condition is met.
For example, suppose that I have saved up for years and years and now have around $100,000 that I want to gamble away--- er, invest, in the Powerball.
In [49]:
my_life_savings = 100000
while my_life_savings > 0: # While I still have money in the bank,
my_life_savings -= 1 # ``-=`` means "subtract one and store the result in the same variable."
# This is the same as writing: my_life_savings = my_life_savings - 1
x = random.random() # Wooo!
if x < 1./292000000:
print 'JACKPOT!!'
break
The statement...
while ...:
says: "as long as the following statement (...) is True, do the following thing over and over and over. Unsurprisingly, this is called a "while" loop. In the example above, we decrement (subtract 1) from our life savings every iteration, and stop when there is no money left (my_life_savings <= 0).
Now, in the extremely unlikely case that I win the Powerball, there's really no incentive to keep playing. In that case, I want to stop the loop prematurely. To do that, I use the command break. break will stop the iteration at that very moment.
WARNING WARNING WARNING: avoid endless loops! If you use a while loop, make sure that the condition for the loop (the part that gets evaluated each iteration) will become False in some reasonable duration of time. Consider what would happen if I removed the line that decremented my life savings (my_life_savings -= 1): we'd go on playing the powerball forever! If you do start an endless loop by accident, use the square "stop" button (or select Kernel > Interrupt) in the menu at the top of the notebook.
Here's another case: suppose I have a bunch of measurements about how often individual ants in a colony of Pogonomyrmex barbatus interact with each other.
I sat there with my little notebook for twenty minutes, and counted the number of times each pair of ants touched antennae. Now I have a list of interaction counts, one entry per pair of ants. It's a small colony, only 4 ants, so there are only $4! = 24$ entries.
In [55]:
interactions = [40, 44, 5, 26, 4, 47, 41, 41, 29, 5, 49, 32, # You can write a list over multiple lines,
31, 6, 13, 13, 38, 42, 35, 34, 49, 43, 23, 21] # just be sure to end the line with a comma.
Now I need to turn those interaction counts into interaction rates, expressed in interactions per minute. I can iterate over the list of interaction counts, perform my math, and store the result in a new list. Notice: my counts are ints, so in order to get a precise result during division I'll need to coerce them into floats.
In [58]:
interaction_frequencies = [] # Make a new, empty list.
for count in interactions: # Each iteration, I get the next item, and I refer to it as ``count``.
frequency = float(count)/20. # Interactions per minute.
interaction_frequencies.append(frequency) # ``append()`` adds the value to the end of the list.
print interaction_frequencies
This is called a for loop (bet you didn't see that coming). Unlike a while loop, which relies on a logical evaluation of some kind, for loops require something to iterate over. We call the thing that we're iterating over the iterator. A list is an iterator: it contains a bunch of elements, and I can get them one at a time.
In [63]:
for number in [0, 1, 2, 3, 4, 5]:
print number
Strings are also iterators! I can get one character at a time:
In [64]:
for character in 'this string':
print character
Frequently you will need to perform a task some specific number of times, but not necessarily because you have an iterator of a particular size. For example, suppose I want to calculate $6!$. I know that I will need to perform four multiplication steps ($6*5*4*3*2$). I can use the function xrange to create an iterator over a specified range of integers. For example:
In [66]:
factorial = 6
for i in xrange(1, factorial - 1): # Yields the ints 1, 2, 3, and 4.
# ``*=`` means "Multiply this value by the value on the right, and store the result in the same variable.
factorial *= factorial - i # The same as: factorial = factorial * (factorial - i)
print factorial